/************************************************************
   Copyright 2008 Abhinav Pobbati

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*************************************************************/

#pragma once

#include "Havok4Xna/Physics/Dynamics/Phantom/HkpPhantom.h"
#include "Havok4Xna/Physics/Dynamics/Action/HkpAction.h"

#pragma unmanaged
#include <Physics/Vehicle/Camera/hkp1dAngularFollowCam.h>
#include <Physics/Vehicle/Camera/hkp1dAngularFollowCamCinfo.h>
#include <Physics/Vehicle/WheelCollide/RayCast/hkpVehicleRaycastWheelCollide.h>
#include <Physics/Vehicle/TyreMarks/hkpTyremarksInfo.h>
#include <Physics/Vehicle/AeroDynamics/hkpVehicleAerodynamics.h>
#include <Physics/Vehicle/Brake/hkpVehicleBrake.h>
#include <Physics/Vehicle/hkpVehicleData.h>
#include <Physics/Vehicle/AeroDynamics/Default/hkpVehicleDefaultAerodynamics.h>
#include <Physics/Vehicle/DriverInput/hkpVehicleDriverInput.h>
#include <Physics/Vehicle/Brake/Default/hkpVehicleDefaultBrake.h>
#include <Physics/Vehicle/Engine/hkpVehicleEngine.h>
#include <Physics/Vehicle/Engine/Default/hkpVehicleDefaultEngine.h>
#include <Physics/Vehicle/Steering/hkpVehicleSteering.h>
#include <Physics/Vehicle/Steering/Default/hkpVehicleDefaultSteering.h>
#include <Physics/Vehicle/Suspension/hkpVehicleSuspension.h>
#include <Physics/Vehicle/Transmission/hkpVehicleTransmission.h>
#include <Physics/Vehicle/VelocityDamper/hkpVehicleVelocityDamper.h>
#include <Physics/Vehicle/DriverInput/Default/hkpVehicleDefaultAnalogDriverInput.h>
#include <Physics/Vehicle/Friction/hkpVehicleFriction.h>
#include <Physics/Vehicle/hkpVehicleInstance.h>
#include <Physics/Vehicle/WheelCollide/hkpVehicleWheelCollide.h>
#include <Physics/Vehicle/WheelCollide/RayCast/hkpVehicleRaycastWheelCollide.h>
#include <Physics/Vehicle/Suspension/Default/hkpVehicleDefaultSuspension.h>
#include <Physics/Vehicle/Transmission/Default/hkpVehicleDefaultTransmission.h>
#include <Physics/Vehicle/VelocityDamper/Default/hkpVehicleDefaultVelocityDamper.h>
#pragma managed

namespace Havok4Xna {
	namespace Physics {
		namespace Dynamics {
			ref class HkpAction;
			ref class HkpUnaryAction;
			interface class HkpPhantomOverlapListener;
		}
	}
}

using Havok4Xna::Physics::Dynamics::HkpAction;
using Havok4Xna::Physics::Dynamics::HkpUnaryAction;
using Havok4Xna::Physics::Dynamics::HkpPhantomOverlapListener;

namespace Havok4Xna {
	namespace Physics {
		namespace Vehicle {
			public ref class Hkp1dAngularFollowCam : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(Hkp1dAngularFollowCam, hkp1dAngularFollowCam)
			};

			public ref class Hkp1dAngularFollowCamCinfo : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(Hkp1dAngularFollowCamCinfo, hkp1dAngularFollowCamCinfo)
			};

			public ref class HkpRejectRayChassisListener : public INativeReference /*REPLACE WITH: public HkpPhantomOverlapListener*/ {
			internal:
				HK_CLASS_INTERNALS(HkpRejectRayChassisListener, hkpRejectRayChassisListener)
			};

			public ref class HkpTyremarkPoint : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpTyremarkPoint, hkpTyremarkPoint)
			};

			public ref class HkpTyremarksInfo : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpTyremarksInfo, hkpTyremarksInfo)
			};

			public ref class HkpTyremarksWheel : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpTyremarksWheel, hkpTyremarksWheel)
			};

			public ref class HkpVehicleAerodynamics : public INativeReference {
			public:
				ref class AerodynamicsDragOutput : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(AerodynamicsDragOutput, hkpVehicleAerodynamics::AerodynamicsDragOutput)
				};

			internal:
				HK_CLASS_INTERNALS(HkpVehicleAerodynamics, hkpVehicleAerodynamics)
			};

			public ref class HkpVehicleBrake : public INativeReference {
			public:
				ref class WheelBreakingOutput : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(WheelBreakingOutput, hkpVehicleBrake::WheelBreakingOutput)
				};

			internal:
				HK_CLASS_INTERNALS(HkpVehicleBrake, hkpVehicleBrake)
			};

			public ref class HkpVehicleData : public INativeReference {
			public:
				ref class WheelComponentParams : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(WheelComponentParams, hkpVehicleData::WheelComponentParams)
				};

			internal:
				HK_CLASS_INTERNALS(HkpVehicleData, hkpVehicleData)
			};

			public ref class HkpVehicleDefaultAerodynamics : public HkpVehicleAerodynamics {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpVehicleDefaultAerodynamics, hkpVehicleDefaultAerodynamics, HkpVehicleAerodynamics)
			};

			public ref class HkpVehicleDriverInput : public INativeReference {
			public:
				ref class FilteredDriverInputOutput : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(FilteredDriverInputOutput, hkpVehicleDriverInput::FilteredDriverInputOutput)
				};

			internal:
				HK_CLASS_INTERNALS(HkpVehicleDriverInput, hkpVehicleDriverInput)
			};

			public ref class HkpVehicleDefaultAnalogDriverInput : public HkpVehicleDriverInput {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpVehicleDefaultAnalogDriverInput, hkpVehicleDefaultAnalogDriverInput, HkpVehicleDriverInput)
			};

			public ref class HkpVehicleDefaultBrake : public HkpVehicleBrake {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpVehicleDefaultBrake, hkpVehicleDefaultBrake, HkpVehicleBrake)
			};

			public ref class HkpVehicleEngine : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpVehicleEngine, hkpVehicleEngine)
			};

			public ref class HkpVehicleDefaultEngine : public HkpVehicleEngine {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpVehicleDefaultEngine, hkpVehicleDefaultEngine, HkpVehicleEngine)
			};

			public ref class HkpVehicleSteering : public INativeReference {
			public:
				ref class SteeringAnglesOutput : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(SteeringAnglesOutput, hkpVehicleSteering::SteeringAnglesOutput)
				};

			internal:
				HK_CLASS_INTERNALS(HkpVehicleSteering, hkpVehicleSteering)
			};

			public ref class HkpVehicleDefaultSteering : public HkpVehicleSteering {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpVehicleDefaultSteering, hkpVehicleDefaultSteering, HkpVehicleSteering)
			};

			public ref class HkpVehicleSuspension : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpVehicleSuspension, hkpVehicleSuspension)
			};

			public ref class HkpVehicleDefaultSuspension : public HkpVehicleSuspension {
			public:
				ref class WheelSpringSuspensionParameters : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(WheelSpringSuspensionParameters, hkpVehicleDefaultSuspension::WheelSpringSuspensionParameters)
				};

			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpVehicleDefaultSuspension, hkpVehicleDefaultSuspension, HkpVehicleSuspension)
			};

			public ref class HkpVehicleTransmission : public INativeReference {
			public:
				ref class TransmissionOutput : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(TransmissionOutput, hkpVehicleTransmission::TransmissionOutput)
				};

			internal:
				HK_CLASS_INTERNALS(HkpVehicleTransmission, hkpVehicleTransmission)
			};

			public ref class HkpVehicleDefaultTransmission : public HkpVehicleTransmission {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpVehicleDefaultTransmission, hkpVehicleDefaultTransmission, HkpVehicleTransmission)
			};

			public ref class HkpVehicleVelocityDamper : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpVehicleVelocityDamper, hkpVehicleVelocityDamper)
			};

			public ref class HkpVehicleDefaultVelocityDamper : public HkpVehicleVelocityDamper {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpVehicleDefaultVelocityDamper, hkpVehicleDefaultVelocityDamper, HkpVehicleVelocityDamper)
			};

			public ref class HkpVehicleDriverInputAnalogStatus : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpVehicleDriverInputAnalogStatus, hkpVehicleDriverInputAnalogStatus)
			};

			public ref class HkpVehicleFrictionDescription : public INativeReference {
			public:
				ref class AxisDescription : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(AxisDescription, hkpVehicleFrictionDescription::AxisDescription) 
				};
				ref class Cinfo : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(Cinfo, hkpVehicleFrictionDescription::Cinfo)
				};

			internal:
				HK_CLASS_INTERNALS(HkpVehicleFrictionDescription, hkpVehicleFrictionDescription)
			};

			public ref class HkpVehicleFrictionStatus : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpVehicleFrictionStatus, hkpVehicleFrictionStatus)
			};

			public ref class HkpVehicleInstance : public HkpUnaryAction {
			public:
				ref class WheelInfo : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(WheelInfo, hkpVehicleInstance::WheelInfo)
				};

			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpVehicleInstance, hkpVehicleInstance, HkpUnaryAction)
			};

			public ref class HkpVehicleWheelCollide : public INativeReference {
			public:
				ref class CollisionDetectionWheelOutput : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(CollisionDetectionWheelOutput, hkpVehicleWheelCollide::CollisionDetectionWheelOutput)
				};

			internal:
				HK_CLASS_INTERNALS(HkpVehicleWheelCollide, hkpVehicleWheelCollide)
			};

			public ref class HkpVehicleRaycastWheelCollide : public HkpVehicleWheelCollide {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpVehicleRaycastWheelCollide, hkpVehicleRaycastWheelCollide, HkpVehicleWheelCollide)
			};

			public ref class HkpVehicleStepInfo : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpVehicleStepInfo, hkpVehicleStepInfo)
			};
		}
	}
}
